home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / archiver / restore.arc / RESTORE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-01-07  |  11.8 KB  |  387 lines
  1. /*
  2.  *----------------------------------------------------------------------------
  3.  *
  4.  *    RESTORE.C : a backup restorer for the Atari ST series
  5.  *
  6.  *    This code was written to complement the very useful `Turtle'
  7.  *    hard disk backup utility.  It essentially does a `cp -r', maintaining
  8.  *    the time stamps on files.  It will create directories as needed
  9.  *    on the receiving filesystem.
  10.  *
  11.  *    This code is copyright (C) by Ross Alexander, Athabasca University,
  12.  *    1988.  It may be freely redistributed and/or modified as long as:
  13.  *        1) This notice appears, &
  14.  *        2) modifications are noted as NOT my work.
  15.  *
  16.  *    I think this programme is OK, but I take no responsibility for
  17.  *    any result (or lack thereof...) of using it.  Caveat Emptor.
  18.  *
  19.  *    Basic Algorithm:
  20.  *
  21.  *        open source directory
  22.  *        count entries, reserve that much memory
  23.  *        reopen source directory, read into memory
  24.  *        sort alphabetically, moving directories to head
  25.  *            of the list.
  26.  *        conditionally create target directory
  27.  *        call self for all directories in list
  28.  *        copy all files in list to target, correcting time stamps
  29.  *        release memory for list
  30.  *
  31.  *----------------------------------------------------------------------------
  32.  */
  33.  
  34. #include        <osbind.h>
  35. #include        <stat.h>
  36. #include        <stdio.h>
  37. #include    <ctype.h>
  38.  
  39. #define         CANDIDATES  ( S_IJRON | S_IJHID | S_IJSYS | S_IJDIR | S_IJWAC )
  40. #define         NULLPTR     ( (char *) 0 )
  41.  
  42. extern char     * malloc();
  43. extern char    * strcpy();
  44.  
  45. /*  this is the stuff at the end of a DMABUFFER                             */
  46.  
  47. typedef struct {
  48.     char            f_fattr;    /* File attributes */
  49.     long            f_tandd;    /* Time and date words */
  50.     long            f_fsize;    /* File size */
  51.     char            f_fname[14];    /* File name */
  52. }               FILEINFO;
  53.  
  54. /*  this is a big enough buffer to do most files in a gulp                  */
  55.  
  56. #define        BUFFER_SIZE    16384    /* utterly arbitrary            */
  57. char            track_buffer[ BUFFER_SIZE ];
  58.  
  59. int        v_flag = 0;    /* verbosity flag                */
  60.  
  61. /*
  62.  *----------------------------------------------------------------------------
  63.  *
  64.  *  make a (longer) path name from a path-name and {dir,file}-name components
  65.  *
  66.  *----------------------------------------------------------------------------
  67.  */
  68.  
  69. char * dircat( path, name )
  70.     char            * path;
  71.     char            * name;
  72.     {
  73.     int             path_len    = strlen( path );
  74.     char            path_buf[ 128 ];    /* _should_ be lots...              */
  75.     char        * scan = path_buf;
  76.  
  77.     strcpy( path_buf, path );
  78.     if ( path_len != 0 && path[ path_len - 1 ] != '\\' )
  79.         strcat( path_buf, "\\" );
  80.     strcat( path_buf, name );
  81.  
  82.     while ( * scan ) {
  83.     if ( isupper( * scan ) ) * scan = tolower( * scan );
  84.     ++ scan;
  85.     }
  86.  
  87.     return strcpy( malloc( strlen( path_buf ) + 1 ), path_buf );
  88. }
  89.  
  90. /*
  91.  *----------------------------------------------------------------------------
  92.  *
  93.  *  count how many entries exist in a directory.  ignores volume labels, ., ..
  94.  *
  95.  *----------------------------------------------------------------------------
  96.  */
  97.  
  98. int get_dir_size( from )
  99.     char        * from;        /* source pathname            */
  100.     {
  101.     DMABUFFER       examine;            /* place to hold these for counting */
  102.     int             status;             /* temp to hold Fs{first|next} value*/
  103.     DMABUFFER       * old_dta   = (DMABUFFER *) Fgetdta();
  104.     char            * globname  = dircat( from, "*.*" );
  105.     int             list_length = 0;
  106.  
  107.     Fsetdta( & examine );               /* read'em here, avoid buss faults! */
  108.     for ( status = Fsfirst( globname, CANDIDATES );
  109.             status == 0;
  110.                 status = Fsnext() )
  111.         if ( examine.d_fname[ 0 ] != '.' )
  112.             ++ list_length;             /* ignore ., ..                     */
  113.  
  114.     Fsetdta( old_dta );
  115.     free( globname );                   /* don't need this any more         */
  116.  
  117.     return list_length;
  118. }
  119.  
  120. /*
  121.  *----------------------------------------------------------------------------
  122.  *
  123.  *  compare two directory entries; subdirectories sort ahead of files
  124.  *
  125.  *----------------------------------------------------------------------------
  126.  */
  127.  
  128. static int dir_comp( a, b )
  129.     FILEINFO        * a;
  130.     FILEINFO        * b;
  131.     {
  132.     int             attr_a = a->f_fattr & S_IJDIR;
  133.     int             attr_b = b->f_fattr & S_IJDIR;
  134.  
  135.     if ( attr_a != attr_b )
  136.         return attr_a ? -1 : 1;         /* directories-ahead-of-files       */
  137.     else
  138.         return strcmp( a->f_fname, b->f_fname );
  139. }
  140.  
  141. /*
  142.  *----------------------------------------------------------------------------
  143.  *
  144.  *  suck in a directory, sort it, return -> entries
  145.  *
  146.  *----------------------------------------------------------------------------
  147.  */
  148.  
  149. FILEINFO * read_sorted_dir( path, length )
  150.     char            * path;
  151.     int             length;
  152.     {
  153.     FILEINFO        * list      = (FILEINFO *) malloc( length * sizeof (FILEINFO) );
  154.     FILEINFO        * scan      = list;
  155.     char            * globname  = dircat( path, "*.*" );
  156.     DMABUFFER       * old_dta   = (DMABUFFER *) Fgetdta();
  157.     DMABUFFER       examine;
  158.     int             status;
  159.  
  160.     Fsetdta( & examine );               /* read'em here, avoid buss faults! */
  161.     for ( status = Fsfirst( globname, CANDIDATES );
  162.             status == 0;
  163.                 status = Fsnext() )
  164.         if ( examine.d_fname[ 0 ] != '.' ) {
  165.             scan->f_fattr = examine.d_fattr;
  166.             scan->f_tandd = examine.d_tandd;
  167.             scan->f_fsize = examine.d_fsize;
  168.             strcpy( scan->f_fname, examine.d_fname );
  169.             ++ scan;
  170.         }
  171.  
  172.     qsort( list, length, sizeof (FILEINFO), dir_comp );
  173.  
  174.     free( globname );
  175.     Fsetdta( old_dta );
  176.  
  177.     return list;
  178. }
  179.  
  180. /*
  181.  *----------------------------------------------------------------------------
  182.  *
  183.  *  copy a file from `from' to `to_path\to_name', in a careful way.
  184.  *
  185.  *----------------------------------------------------------------------------
  186.  */
  187.  
  188. char * copy_file( from, to_path, to_name )
  189.     char            * from;
  190.     char            * to_path;
  191.     char            * to_name;
  192.     {
  193.     DMABUFFER       * old_dta   = (DMABUFFER *) Fgetdta();
  194.     char            * to        = dircat( to_path, to_name );
  195.     char            * tmp       = dircat( to_path, "$$$$$$$$.$$$" );
  196.     char            * ret_msg   = NULLPTR;
  197.  
  198.     struct stat     stat_from;
  199.     struct stat     stat_to;
  200.  
  201.     int             from_h      = -1;
  202.     int             to_h        = -1;
  203.     int             dest_exists;
  204.     long            chunk;
  205.     int             timestamp[ 2 ];
  206.  
  207.     if ( v_flag )
  208.     fprintf( stderr, "\t%s ==> %s\n", from, to );
  209.  
  210.     /* check existence & modes of source                                    */
  211.     if ( stat( from, & stat_from ) == NODEV ) {
  212.         ret_msg = "can't stat source";
  213.         goto exit;
  214.     }
  215.  
  216.     /* check existence & type of destination                                */
  217.     if ( dest_exists = ( stat( to, & stat_to ) != NODEV ) ) {
  218.         if ( stat_to.st_mtime > stat_from.st_mtime ) {
  219.             ret_msg = "source older than destination";
  220.             goto exit;
  221.         } else if ( ( stat_to.st_mode & S_IJDIR ) != 0 ) {
  222.             ret_msg = "destination is directory";
  223.             goto exit;
  224.         }
  225.     }
  226.  
  227.     /* open source file for reading                                         */
  228.     from_h = Fopen( from, 0 );
  229.     if ( from_h < 0 ) {
  230.         ret_msg = "can't open input file";
  231.         goto exit;
  232.     }
  233.  
  234.     /* create the temporary output file                                     */
  235.     to_h = Fcreate( tmp, stat_from.st_mode );
  236.     if ( to_h < 0 ) {
  237.         ret_msg = "can't create temp file";
  238.         goto exit;
  239.     }
  240.  
  241.     /* copy file contents across                                            */
  242.     Fsetdta( track_buffer );
  243.     while ( stat_from.st_size > 0 ) {
  244.         chunk = stat_from.st_size > BUFFER_SIZE ?
  245.         BUFFER_SIZE : stat_from.st_size;
  246.  
  247.         if ( chunk != Fread( from_h, chunk, track_buffer ) ) {
  248.             ret_msg = "file read error";
  249.             goto exit;
  250.         }
  251.  
  252.         if ( chunk != Fwrite( to_h, chunk, track_buffer ) ) {
  253.             ret_msg = "temp file write error";
  254.             goto exit;
  255.         }
  256.  
  257.         stat_from.st_size -= chunk;
  258.     }
  259.  
  260.     /* close output, delete destination, rename temp to destination         */
  261.     Fclose( to_h );
  262.     to_h = -1;
  263.     if ( dest_exists && Fdelete( to ) != 0 ) {
  264.         ret_msg = "can't delete destination";
  265.         goto exit;
  266.     }
  267.  
  268.     if ( Frename( 0, tmp, to ) ) {
  269.         ret_msg = "rename failed";
  270.         goto exit;
  271.     }
  272.  
  273.     /* copy old timestamp to new file                                       */
  274.     to_h = Fopen( to, 1 );
  275.     Fdatime( timestamp, from_h, 0 );
  276.     Fdatime( timestamp, to_h, 1 );
  277.  
  278.     /* sweep up                                                             */
  279. exit:
  280.     if ( from_h >= 0 )
  281.         Fclose( from_h );
  282.     if ( to_h >= 0 )
  283.         Fclose( to_h );
  284.  
  285.     Fsetdta( old_dta );
  286.     free( to );
  287.     free( tmp );
  288.  
  289.     return ret_msg;
  290. }
  291.  
  292. /*
  293.  *----------------------------------------------------------------------------
  294.  *
  295.  *  drive all the other routines ;-)
  296.  *
  297.  *----------------------------------------------------------------------------
  298.  */
  299.  
  300. char * cp_hyphen_r( from, to )
  301.     char            * from;
  302.     char            * to;
  303.     {
  304.     struct stat     stat_from;
  305.     struct stat     stat_to;
  306.  
  307.     int             how_many;
  308.     FILEINFO        * list;
  309.     FILEINFO        * scan;
  310.  
  311.     char            * from_next;
  312.     char            * to_next;
  313.     char            * t;
  314.  
  315.     if ( v_flag )
  316.     fprintf( stderr, "%s --> %s\n", from, to );
  317.  
  318.     /* guarantee that source exists and is a directory                      */
  319.     if ( stat( from, & stat_from ) == NODEV
  320.             || ( stat_from.st_mode & S_IJDIR ) == 0 )
  321.         return "source not found or not directory";
  322.  
  323.     /* see if destination exists; if not, try to create it                  */
  324.     if ( stat( to, & stat_to ) != NODEV ) {
  325.         if ( ( stat_to.st_mode & S_IJDIR ) == 0 )
  326.             return "destination exists & not directory";
  327.     } else
  328.         if ( Dcreate( to ) )
  329.             return "can't create destination directory";
  330.  
  331.     /* now either call self for dir's, or copy files                        */
  332.     scan =
  333.     list = read_sorted_dir( from, how_many = get_dir_size( from ) );
  334.     while ( scan < list + how_many ) {
  335.         from_next = dircat( from, scan->f_fname );
  336.         to_next = dircat( to, scan->f_fname );
  337.  
  338.         if ( ( scan->f_fattr & S_IJDIR ) != 0 ) {
  339.             if ( ( t = cp_hyphen_r( from_next, to_next ) ) != NULLPTR )
  340.                 fprintf( stderr, "%s (%s -> %s)\n", t, from_next, to_next );
  341.         } else
  342.             if ( ( t = copy_file( from_next, to, scan->f_fname ) ) != NULLPTR )
  343.                 fprintf( stderr, "%s (%s -> %s)\n", t, from_next, to_next );
  344.  
  345.         free( from_next );
  346.         free( to_next );
  347.         ++ scan;
  348.     }
  349.  
  350.     free( list );
  351.     return NULLPTR;
  352. }
  353.  
  354. /*  user interface                                                          */
  355.  
  356. main( argc, argv )
  357.     int             argc;
  358.     char            * * argv;
  359.     {
  360.     char            * errmsg;
  361.  
  362.     int            c;
  363.     extern int        optind;
  364.     extern char *   optarg;
  365.  
  366.     while ( ( c = getopt( argc, argv, "v" ) ) != EOF )
  367.     if ( c == 'v' )
  368.         ++ v_flag;
  369.     else
  370.         break;
  371.  
  372.     if ( c != EOF || ( argc - optind ) != 2 ) {
  373.     fprintf( stderr, "%s: usage %s [-v] <src-dir> <dest-dir>\n",
  374.         argv[ 0 ], argv[ 0 ] );
  375.     exit( 1 );
  376.     }
  377.  
  378.     if ( ( errmsg = cp_hyphen_r( argv[ optind ], argv[ optind + 1 ] ) )
  379.         != NULLPTR ) {
  380.     fprintf( stderr, "%s: %s (%s --> %s)\n",
  381.         argv[ 0 ], errmsg, argv[ optind ], argv[ optind + 1 ] );
  382.     exit( 2 );
  383.     }
  384.  
  385.     exit( 0 );
  386. }
  387.